import translate from '@/components/utils/translate';
import requestFile from "@/components/utils/requestFile";
import request from "@/components/utils/request";
/**
 * 多语言互译工具 - 实现中文(zh)、英文(en)、俄文(ru)三语种间的双向翻译
 *
 * @async
 * @function translate_zh_en_ru
 *
 * @param {string} text - 待翻译的原始文本内容
 * @param {string} from - 源语言代码（必须为'zh'/'en'/'ru'三者之一）
 * @param {number} type - 翻译引擎配置类型 1：代表纯文本翻译；2：代码html语言翻译
 *
 * @returns {Promise<Object>} 返回包含三语翻译结果的Promise对象，结构如下：
 *   {
 *     zh: '中文翻译结果',  // 中文译文
 *     en: 'English translation', // 英文译文
 *     ru: 'Русский перевод'     // 俄文译文
 *   }
 *
 * @description
 * 函数根据源语言类型采用不同翻译策略：
 * 1. 中文源语(zh)：并行翻译至英文和俄文（Promise.all并行处理）
 * 2. 英文源语(en)：先翻译至中文，再通过中文中转翻译至俄文（链式调用）
 * 3. 俄文源语(ru)：先翻译至中文，再通过中文中转翻译至英文（链式调用）
 *
 * @example
 * // 中译英俄并行翻译
 * translate_zh_en_ru('你好', 'zh', 'general')
 *   .then(res => console.log(res))
 *   // 输出: { zh: '你好', en: 'Hello', ru: 'Привет' }
 *
 * // 英译中俄链式翻译
 * translate_zh_en_ru('Hello', 'en', 'general')
 *   .then(res => console.log(res.ru)) // 输出俄文译文
 *
 * @note
 * - 链式翻译模式可能导致俄文/英文翻译延迟（需等待中文翻译完成）
 * - 默认返回包含所有语种的对象，未翻译语种保持空字符串
 * - 异常处理：非zh/en/ru的from参数将直接返回空对象
 */
//利用小牛翻译，进行：中\英\俄三语之间互相翻译
export async function translate_zh_en_ru(text, from, type) {
    const results = { zh: '', en: '', ru: '' };

    // 设置源语言文本
    results[from] = text;

    switch (from) {
        case 'zh':
            // 返回并行翻译的Promise
            return Promise.all([
                translate(text, from, 'en', type).then(data => results.en = data),
                translate(text, from, 'ru', type).then(data => results.ru = data)
            ]).then(() => results);

        case 'en':
            // 链式处理中转翻译
            return translate(text, from, 'zh', type)
                .then(zhData => {
                    results.zh = zhData;
                    // 添加俄语翻译（中转）
                    return translate(zhData, 'zh', 'ru', type)
                        .then(ruData => results.ru = ruData);
                })
                .then(() => results);

        case 'ru':
            // 链式处理中转翻译
            return translate(text, from, 'zh', type)
                .then(zhData => {
                    results.zh = zhData;
                    // 添加英语翻译（中转）
                    return translate(zhData, 'zh', 'en', type)
                        .then(enData => results.en = enData);
                })
                .then(() => results);

        default:
            return Promise.resolve(results);
    }
}
/**
 * 生成符合RFC 4122标准的v4版本UUID（通用唯一标识符）
 *
 * @async
 * @function generateUUIDv4
 *
 * @returns {Promise<string>} 返回一个32字符的十六进制UUID字符串（不含连字符），格式示例：
 *   "f47ac10b58cc4372a5670e02b2c3d479"
 *
 * @description
 * 该函数通过加密安全的随机数生成器（crypto.getRandomValues）创建v4 UUID，符合以下规范：
 * 1. 版本位（Version）：第6字节的高4位设置为0100（二进制）
 * 2. 变体位（Variant）：第8字节的高2位设置为10（二进制）
 * 3. 其余位使用加密安全的随机数填充
 *
 * @example
 * // 生成UUID并打印
 * generateUUIDv4().then(uuid => {
 *   console.log('Generated UUID:', uuid);
 *   // 输出示例: "1a2b3c4d5e6f708192a3b4c5d6e7f809"
 * });
 *
 * // 使用async/await语法
 * async function createResource() {
 *   const id = await generateUUIDv4();
 *   console.log('Resource ID:', id);
 * }
 *
 * @note
 * - 依赖浏览器或Node.js的crypto模块（Web Crypto API）
 * - 生成的UUID理论碰撞概率极低（1/2^122）
 * - 在Node.js环境中需确保crypto模块可用（默认内置）
 */
export function generateUUIDv4() {
    const bytes = new Uint8Array(16);
    crypto.getRandomValues(bytes);

    // 设置版本位（第6字节的高4位为0100）
    bytes[6] = (bytes[6] & 0x0f) | 0x40;
    // 设置变体位（第8字节的高2位为10）
    bytes[8] = (bytes[8] & 0x3f) | 0x80;

    // 转换为32字符十六进制字符串
    return Array.from(bytes, byte => {
        return byte.toString(16).padStart(2, '0');
    }).join('');
}

/**
 * 上传一个文件，功能包括，可以实现新上传一个文件、删除老文件同时上传新文件、删除一个文件
 * @param {int} type - 处理文件的类型，1：代表新增一个文件；2：代表删除一个老文件，同时传入一个新文件，3：代表删除一个老文件
 * @param {file} newFile - 传入的文件；需要直接传war
 * @param {string} newFileName -传入文件的名称
 * @param {string} oldFileName - 老文件名称，代表要删除的文件名称
 * */

export async function Util_Edit_One_File(type,newFileName,newFile,oldFileName){
    console.log('1')
    //进行校核，校核传入新的文件
    if (type===1){
        if (newFileName==='' || newFileName===null || newFileName===undefined){
            console.log('2')
            return '新文件名称未传入'
        }
        if (typeof File === 'undefined' || !(newFile instanceof File)){
            console.log('3')
            return '传入的文件不正确'
        }
    }
    if (type===2){
        if (newFileName==='' || newFileName===null || newFileName===undefined){
            return '新文件名称未传入'
        }
        if (typeof File !== 'undefined' || !(newFile instanceof File)){
            return '传入的文件不正确'
        }
        if (oldFileName==='' || oldFileName===null || oldFileName===undefined){
            return '老文件名称/删除的文件名称不正确'
        }
    }
    if (type===3){
        console.log("11111")
        if (oldFileName==='' || oldFileName===null || oldFileName===undefined){
            return '老文件名称/删除的文件名称不正确'
        }
    }
    //向后端传递，进行文件操作
    //是对图片的操作
    const formData = new FormData()
    formData.append('type',type)
    formData.append('newFileName',newFileName)
    formData.append('oldFileName',oldFileName)
    formData.append('newFile',newFile)
    //向后端传递信息
    try {
        const result = await requestFile.post('/editOneFileBase', formData); // 添加 await
        if (result.code === 401) {
            this.$router.push('UserLogin');
            return '请先登录'; // 实际返回给调用者
        }
        else {
            if (result.data==='操作成功'){
                return '操作成功'; // 同步返回结果
            }
            else {
                return '操作失败'; // 同步返回结果
            }
        }

    } catch (error) {
        return `请求失败: ${error.message}`; // 捕获网络错误
    }

}
/**
 * 下载文件的工具类
  */

export async function Util_Download_File(fileName) {
    try {
        const result = await request.get('/downloadFileBaseComponent?fileName=' + encodeURIComponent(fileName));

        if (result.code === 401) {
            return "未登录"
        } else {
            let base64Data = 'data:application/octet-stream;base64,' + result.data
            let blob = dataURItoBlob(base64Data);
            downloadBlob(blob, fileName);
            return "下载成功"
        }
    } catch (error) {
        console.error("请求出错", error);
        return "未下载成功"
    }
}

/**
 * 调用所有的零部件明细，并且组合成为一个选择器
 * */
//辅助函数：对零部件信息进行调用,调用所有的信息
export async function inquiryProductListBaseComponentAll(){
    try{
        const result = await request.post('/inquiryProductListBaseComponentAll')
        if (result.code === 401) {
            return '您未登录'
        } else {
            let productModelList=result.data
            //整理出来选择器
            let productModelListOption={
                chinese:[],
                english:[],
                russian:[]
            }
            for (let i = 0; i < productModelList.length; i++) {
                productModelListOption.chinese.push({label:productModelList[i].cpxh+'/'+productModelList[i].lbjmc_C,value:productModelList[i].cpxh+'/'+productModelList[i].lbjmc_C+'/'+productModelList[i].lbjmc_E+'/'+productModelList[i].lbjmc_R+'/'+productModelList[i].sccj,})
                productModelListOption.english.push({label:productModelList[i].cpxh+'/'+productModelList[i].lbjmc_E,value:productModelList[i].cpxh+'/'+productModelList[i].lbjmc_C+'/'+productModelList[i].lbjmc_E+'/'+productModelList[i].lbjmc_R+'/'+productModelList[i].sccj,})
                productModelListOption.russian.push({label:productModelList[i].cpxh+'/'+productModelList[i].lbjmc_R,value:productModelList[i].cpxh+'/'+productModelList[i].lbjmc_C+'/'+productModelList[i].lbjmc_E+'/'+productModelList[i].lbjmc_R+'/'+productModelList[i].sccj,})
            }
            // 消除重复项
            productModelListOption.chinese = [...new Set(productModelListOption.chinese.map(item => JSON.stringify(item)))].map(itemString => JSON.parse(itemString));
            productModelListOption.english = [...new Set(productModelListOption.english.map(item => JSON.stringify(item)))].map(itemString => JSON.parse(itemString));
            productModelListOption.russian = [...new Set(productModelListOption.russian.map(item => JSON.stringify(item)))].map(itemString => JSON.parse(itemString));
            //返回选择器的结果
            return productModelListOption
        }
    }
    catch (error){
        console.error("请求出错", error);
        return "未连接到服务器"
    }
}

// 辅助函数：将Base64编码的字符串转换为Blob对象
function dataURItoBlob(dataURI) {
    // 分离出头部信息,得到数据部分
    let byteString;
    if (dataURI.split(',')[0].indexOf('base64') >= 0)
        byteString = atob(dataURI.split(',')[1]);
    else
        byteString = unescape(dataURI.split(',')[1]);

    // 写入数组缓冲区
    let mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];
    let ia = new Uint8Array(byteString.length);
    for (let i = 0; i < byteString.length; i++) {
        ia[i] = byteString.charCodeAt(i);
    }
    return new Blob([ia], {type:mimeString});
}
// 辅助函数：触发Blob对象的下载
function downloadBlob(blob, fileName) {
    let link = document.createElement('a');
    link.href = window.URL.createObjectURL(blob);
    link.download = fileName;
    link.click();
    window.URL.revokeObjectURL(link.href);
}

/**
 *
 * @param {string} dingId - //机器人的地址号
 * @param {string} dingIdentifyId  - //机器人的识别号
 * @param {string} text -//发送的文字部分
 * @param {string} link -//需要发送的链接
 * @param {string} type -//类型，1：纯文本；2：链接
 * 向钉钉群发送消息*/
export function dingMessage(dingId,dingIdentifyId,text,link,type){
    //向后端发送消息，去基础控制层操作
    const result = request.post('/dingMessageBasic',{
        dingId:dingId,
        dingIdentifyId:dingIdentifyId,
        text:text,
        link:link,
        type:type
    })
    if (result.code === 401) {
        alert('您未登录')
        return '您未登录'
    } else {
        if (result.data==='消息发送成功'){
            return result.data
        }
    }
}